<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        var arr = [1, 2, 3, 1, 2, 3, 1, 2, 3]
        /* 
            解决方案四:
                第一次:将数组的第一个元素与后面的每一个元素进行比较是否相当,如果相等,记录他的下标,干掉这个下标
                //定义一个下标
                var index = -1;
                for(var i = 0 ; i < arr.length ; i++){
                    for(var j = i+1 ; j < arr.length ; j ++){
                        if(arr[i] === arr[j]){
                            //记录这个下标
                            index = j;
                        }
                    }
                }
        */
        // for(var i = 0 ; i < arr.length ; i++){
        //     for(var j = i+1 ; j < arr.length ; j ++){
        //         if(arr[i] === arr[j]){
        //             //记录这个下标
        //             arr.splice(j,1)
        //             //解决数组塌陷
        //             j--
        //         }
        //     }
        // }
        // console.log(arr);

        arr.forEach(function(item,i){
            for(var j = i+1 ; j < arr.length ; j ++){
                if(arr[i] === arr[j]){
                    //记录这个下标
                    arr.splice(j,1)
                    //解决数组塌陷
                    j--
                }
            }
        })
        console.log(arr);





        /* 
            解决方案三:
                思路前的准备知识点:
                    我们的目的是数组去重,我们利用某一个语法具有唯一性的语法来实现去重
                    Object => key:value 其中 key 是唯一的
                    var obj = {
                        name:"张三"
                        name:"李四"
                    }
                思路:
                    遍历该数组,将数组里面每一个元素都扔到对象的key中去,对象的value不用管他
                    var obj = {
                        1:"文渊",
                        2:"文渊",
                        3:"文渊"
                        // 1:"文渊"     当对象的key重复的时候,后面的key会覆盖掉前面的key,所以我们利用这个特性来实现去重
                    }
                    1.创建一个对象
                        var o = {}
                    2.遍历数组,将数组里面每一个元素都扔到对象的key当中
                        for(var i = 0 ; i<arr.length ; i++){
                            //console.log(arr[i]);  表示数组里面的每一个元素
                            var element = arr[i]
                            //将这个元素交给对象的key值,value无所谓
                            o[element] = "文渊"
                        }
                    3. 那这个对象
                        {
                            1:"文渊"
                            2:"文渊"
                            3:"文渊"
                        }
                    4.再将对象的key扔到数组里面去
                        var arr0 = []
                    5.遍历这个对象
                        for(var key in o){
                            arr0.push(key)
                        }
                        console.log(arr0)
        */
            //1. 创建一个对象
            // var obj = {}
            // //2. 遍历数组
            // for(var i = 0 ; i < arr.length ; i++){
            //     //获取数组里面的每一个元素
            //     var el = arr[i]
            //     //将数组里面的每一个元素扔到对象的key去,value无所谓
            //     obj[el] = "文哥"
            // }
            // //3.创建一个新的数组
            // var arr0 = []
            // //将对象key扔到数组里面去
            // for(var key in obj){
            //     arr0.push(+key)
            // }
            // //打印新数组
            // console.log(arr0);



        /* 
            解决方案一:
                1. 对数组进行排序
                    [1,1,1,2,2,2,3,3,3]  
                2. 遍历这个数组,如果上一个和下一个是相同的,那么就删除一个
                    for(var i = 0 ; i < arr.length ; i++){
                        if(arr[i] === arr[i+1]){
                            //干掉一个
                            arr.splice(i,1)
                            //数组塌陷
                            i--
                        }
                    }
        */
        //1. 先排序一下
        // arr.sort(function(a,b){return a - b})
        // //2. 数组去重
        // for (var i = 0; i < arr.length; i++) {
        //     if (arr[i] === arr[i + 1]) {
        //         //干掉一个
        //         arr.splice(i, 1)
        //         //数组塌陷
        //         i--
        //     }
        // }
        // console.log(arr);




        /* 
            解决方案二:
                var arr = [1, 2, 3, 1, 2, 3, 1, 2, 3]
                1.创建新的数组
                    var arr1 = []
                2.遍历老数组,如果新的数组里面的元素在新数组当中已经存在了,使用indexOf去找那个老数组里面的元素在新数组的里面有没有存在的元素
                    如果有 使用 indexOf 判断 不等于 -1
                    如果没有 使用indexOf 判断 等于 -1   =>  将老数组里面的那个元素.push到新的数组里面去
                    for(var i = 0 ; i < arr.length ; i++){
                        //arr1.indexOf(arr[i]) === -1  老数组当中没有那个遍历出来的元素,往新数组里面扔.push
                        if(arr1.indexOf(arr[i]) === -1){
                            arr1.push(arr[i])
                        }
                    }
        */
        // var arr = [1, 2, 3, 1, 2, 3, 1, 2, 3]
        // //创建一个新的数组
        // var arr1 = []
        // //遍历老数组里面的每一个元素
        // for(var i = 0 ; i < arr.length ; i++){
        //     //arr1.indexOf(arr[i]) === -1 利用新的数组来找老数组遍历出来的那个元素,找不到就-1,-1就将这个元素扔到新的数组里面去
        //     //如果不等于-1,那么表是遍历出来的老数组的元素已经在新的数组里面已经存在了,那么不就管
        //     if(arr1.indexOf(arr[i]) === -1){
        //         // 等于 -1 表示新数组里面没有老数组的遍历出来那个元素,没有就Push
        //         arr1.push(arr[i])
        //     }
        // }
        // console.log(arr1);
    </script>
</body>

</html>